home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 001-025 / disk_023 / ver30 / tty / intuition / ttymenu.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  7KB  |  268 lines
  1. /*
  2.  * Name:    MicroEmacs
  3.  *         Commodore Amiga Intuition menus
  4.  * Version:    31
  5.  * Last edit:    20-Apr-86 ...!ihnp4!seismo!ut-sally!ut-ngp!mic
  6.  * Created:    20-Apr-86 ...!ihnp4!seismo!ut-sally!ut-ngp!mic
  7.  */
  8.  
  9. #include <exec/types.h>
  10. #include <exec/memory.h>
  11. #include <graphics/text.h>
  12. #include <libraries/diskfont.h>
  13. #include <intuition/intuition.h>
  14. #undef    TRUE
  15. #undef    FALSE
  16. #include "def.h"    /* Also includes "sysdef.h" and "ttydef.h" */
  17.  
  18. /*
  19.  * When ttgetc() sees a menu selection event, it stuffs
  20.  * the sequence <CSI>M~ into the input buffer, and
  21.  * caches the menu number and item number for later.
  22.  * This sequence is translated into the internal key code
  23.  * KMENU, similar to KHELP and the other function keys.
  24.  *
  25.  * The menu item names are chosen to be relatively close
  26.  * to the extended function names, so a user can usually
  27.  * figure out the key binding of a menu item by searching
  28.  * through the "display-bindings" buffer for something
  29.  * that's close.
  30.  */
  31.  
  32. /*
  33.  * Commands for managing files
  34.  */
  35.  
  36. static struct MenuBinding FileItems[] = {
  37.     { "Read File",        "file-read",        },
  38.     { "Save File",        "file-save",        },
  39.     { "Visit File",        "file-visit",        },
  40.     { "Write File",        "file-write"        },
  41.     { "Insert File",    "file-insert"        },
  42.     { "Set File Name",    "set-file-name"        },
  43.     { "Quit",        "quit",            }
  44. };
  45.  
  46. /*
  47.  * Commands for various editing functions
  48.  */
  49.  
  50. static struct MenuBinding EditItems[] = {
  51.     { "Forward Del Char",    "forw-del-char"        },
  52.     { "Kill Line",        "kill-line"        },
  53.     { "Yank",        "yank"            },
  54.     { "Delete Blank Lines",    "del-blank-lines"    },
  55.     { "NL And Indent",    "ins-nl-and-indent"    },
  56.     { "Twiddle",        "twiddle"        },
  57.     { "Quote Character",    "quote"            }
  58. };
  59.  
  60. /*
  61.  * Movement commands
  62.  */
  63.  
  64. static struct MenuBinding MoveItems[] = {
  65.     { "Beg. Of  Line",    "goto-bol"        },
  66.     { "Beg. Of  Paragraph",    "goto-bop"        },
  67.     { "Beg. Of  Buffer",    "goto-bob"        },
  68.     { "End Of   Line",    "goto-eol"        },
  69.     { "End Of   Paragraph",    "goto-eop"        },
  70.     { "End Of   Buffer",    "goto-eob"        },
  71.     { "Goto Line",        "goto-line"        },
  72.     { "Show Cursor Pos",    "display-position"    }
  73. };
  74.  
  75. /*
  76.  * Commands for searching and replacing
  77.  */
  78.  
  79. static struct MenuBinding SearchItems[] = {
  80.     { "Search Again",    "search-again"    },
  81.     { "Forward  I-Search",    "forw-i-search"    },
  82.     { "Backward I-Search",    "back-i-search"    },
  83.     { "Forward  Search",    "forw-search"    },
  84.     { "Backward Search",    "back-search"    },
  85.     { "Query Replace",    "query-replace"    },
  86. };
  87.  
  88. /*
  89.  * Commands that manipulate words
  90.  */
  91. static struct MenuBinding WordItems[] = {
  92.     { "Forward  Word",    "forw-word"        },
  93.     { "Backward Word",    "back-word"        },
  94.     { "Forward Del Word",    "forw-del-word"     },
  95.     { "Backward Del Word",    "back-del-word"     },
  96.     { "Capitalize Word",    "cap-word"        },
  97.     { "Lowercase  Word",    "lower-word"        },
  98.     { "Uppercase  Word",    "upper-word"        },
  99.     { "Fill Paragraph",    "fill-paragraph"    },
  100.     { "Set Fill Column",    "set-fill-column"    }
  101. };
  102.  
  103. /*
  104.  * Region management
  105.  */
  106.  
  107. static struct MenuBinding RegionItems[] = {
  108.     { "Set Mark",        "set-mark"        },
  109.     { "Swap Dot And Mark",    "swap-dot-and-mark"    },
  110.     { "Kill Region",    "kill-region"        },
  111.     { "Copy Region",    "copy-region"        },
  112.     { "Lowercase Region",    "lower-region"        },
  113.     { "Uppercase Region",    "upper-region"        }
  114. };
  115.  
  116. /*
  117.  * Buffer management
  118.  */
  119.  
  120. static struct MenuBinding BufferItems[] = {
  121.     { "Use Buffer",        "use-buffer"         },
  122.     { "Kill Buffer",    "kill-buffer"        },
  123.     { "Display Buffers",    "display-buffers"    },
  124.     { "Rename Buffer",    "rename-buffer"        }
  125. };
  126.  
  127. /*
  128.  * Commands for manipulating windows
  129.  */
  130.  
  131. static struct MenuBinding WindowItems[] = {
  132.     { "Refresh Screen",    "refresh"        },
  133.     { "Reposition Window",    "reposition-window"    },
  134.     { "Split Window",    "split-window"        },
  135.     { "One Window",        "only-window"        },
  136.     { "Next Window",    "forw-window"        },
  137.     { "Previous Window",    "back-window"        },
  138.     { "Move Window Down",    "down-window"        },
  139.     { "Move Window Up",    "up-window"        },
  140.     { "Enlarge Window",    "enlarge-window"    },
  141.     { "Shrink Window",    "shrink-window"        }
  142. };
  143.  
  144. /*
  145.  * Miscellaneous commands
  146.  */
  147.  
  148. static struct MenuBinding MiscItems[] = {
  149.     { "About MicroEMACS",    "display-version"    },
  150.     { "Start Macro",    "start-macro"        },
  151.     { "End Macro",        "end-macro"        },
  152.     { "Execute Macro",    "execute-macro"        },
  153.     { "Extended Command",    "extended-command"    },
  154.     { "Bind Key",        "bind-to-key"        },
  155.     { "Display Bindings",    "display-bindings"    },
  156.     { "CLI Subprocess",    "spawn-cli"        }
  157. };
  158.  
  159. /*
  160.  * The following table contains the titles, number of
  161.  * items, and pointers to, the individual menus.
  162.  *
  163.  * The MenuWidth field is the number of characters
  164.  * in the longest item name.
  165.  */
  166.  
  167. static struct MenuInfo EMInfo[] = {
  168.     { "File",    NITEMS(FileItems),    13,    &FileItems[0]    },
  169.     { "Edit",    NITEMS(EditItems),    18,    &EditItems[0]    },
  170.     { "Move",     NITEMS(MoveItems),    18,    &MoveItems[0]    },
  171.     { "Search",    NITEMS(SearchItems),    17,    &SearchItems[0] },
  172.     { "Word",    NITEMS(WordItems),    17,    &WordItems[0]    },
  173.     { "Region",    NITEMS(RegionItems),    17,    &RegionItems[0]    },
  174.     { "Buffer",    NITEMS(BufferItems),    15,    &BufferItems[0]    },
  175.     { "Window",    NITEMS(WindowItems),    17,    &WindowItems[0] },
  176.     { "Misc",    NITEMS(MiscItems),    16,    &MiscItems[0]    }
  177. };
  178.  
  179. /*
  180.  * Initialize the MicroEmacs menus.
  181.  *
  182.  * Returns a pointer to the first menu header in
  183.  * the menu list back to the caller.
  184.  *
  185.  * Makes the assumption that the font for
  186.  * the window being used is 8 pixels wide --
  187.  * a safe bet with the version 1.1 ROM Kernel.
  188.  */
  189.  
  190. struct Menu *InitEmacsMenu()
  191. {
  192.     struct Menu *EMMenu, *NewMenu(), *AddMenu();
  193.     struct MenuItem *AddNewMenuItem(), *AddItem(), *AddNewSubItem();
  194.  
  195.     register struct Menu *cm;
  196.     register struct MenuInfo *cinf, *lastinfo;/* current menu info    */
  197.  
  198.     lastinfo = &EMInfo[NITEMS(EMInfo)];    /* sentinel for loop    */
  199.  
  200.     for (cinf = EMInfo; cinf < lastinfo; cinf++) {
  201.         if (cinf == EMInfo)        /* create menu header    */
  202.             EMMenu = cm = NewMenu(cinf->Name,
  203.                 strlen(cinf->Name) * 8 + 6, 10);
  204.         else
  205.             cm = AddMenu(cm,
  206.                 cinf->Name,strlen(cinf->Name) * 8 + 6, 10);
  207.         MakeMenu(cinf,cm,cinf->MenuWidth * 8 + 2, 10);
  208.     }
  209.     return EMMenu;
  210. }
  211.  
  212. /*
  213.  * Put menu items in a menu.  Width and
  214.  * height control the respective
  215.  * sizes of the menu items.
  216.  */
  217.  
  218. static    MakeMenu(cinf,cm,width,height)
  219. struct MenuInfo *cinf;
  220. struct Menu *cm;
  221. int width, height;
  222. {
  223.     struct Menu *NewMenu(), *AddMenu();
  224.     struct MenuItem *AddNewMenuItem(), *AddItem(), *AddNewSubItem();
  225.  
  226.     register struct MenuBinding *cb, *lastbinding;
  227.     register struct MenuItem *ci;
  228.  
  229.     lastbinding = &cinf->Items[cinf->NumItems];
  230.     for (cb = cinf->Items; cb < lastbinding; cb++) {
  231.         if (cb == cinf->Items)
  232.             ci = AddNewMenuItem(cm, cb->Command, width, height);
  233.         else
  234.             ci = AddItem(ci, cb->Command);
  235.     }
  236. }
  237.  
  238. /*
  239.  * Menu command.   Get the name of the command to
  240.  * perform from the menu binding table, then
  241.  * run the command if it is found and has the
  242.  * right type. Print an error if there is anything
  243.  * wrong.
  244.  */
  245. extern ttmenu();            /* Defined in "ttyio.c"     */
  246.                     /* Returns last menu selection    */
  247. amigamenu(f, n, k)
  248. {
  249.     register SYMBOL    *sp, *symlookup();
  250.     char        *xname;
  251.     int MenuNum, ItemNum, SubItem;
  252.  
  253.     ttmenu(&MenuNum,&ItemNum,&SubItem);
  254.  
  255.     /* check for spurious numbers */
  256.     if ((MenuNum < 0) || (MenuNum >= NITEMS(EMInfo)))
  257.         return (FALSE);
  258.     if ((ItemNum < 0) || (ItemNum >= EMInfo[MenuNum].NumItems))
  259.         return (FALSE);    
  260.  
  261.     xname = EMInfo[MenuNum].Items[ItemNum].Binding;
  262.  
  263.     if ((sp=symlookup(xname)) != NULL)
  264.         return ((*sp->s_funcp)(f, n, KRANDOM));
  265.     eprintf("Unknown menu command");
  266.     return (ABORT);
  267. }
  268.